home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / Crypt.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  17KB  |  726 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysCrypt.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    int OpenCryptWindow ( void );
  12.    *    void CryptFile ( void );
  13.    *
  14.    *      --- Lokale  Routinen ---
  15.    *
  16.    *    static UBYTE *Decrypt ( UBYTE *Source , long SourceLen , UBYTE *Destination , UBYTE *Key , WORD KeyLen );
  17.    *    static UBYTE *Encrypt ( UBYTE *Source , long SourceLen , UBYTE *Destination , UBYTE *Key , WORD KeyLen );
  18.    *    static UBYTE Automaton ( void );
  19.    *    static void Crypt ( int encrypt );
  20.    *    static void MakeROT13 ( UBYTE *buff , UBYTE *dest );
  21.    *    static void refreshstrgad ( GADGET *gad , char *str );
  22.    *    static void WindTitleInfo ( char *msg );
  23.    *
  24.    * Bemerkungen:
  25.    *      Verschlüsselungsroutinen von RSys.
  26.    *
  27.    * Erstellungsdatum:
  28.    *      07-Jul-93     Rolf Böhme
  29.    *
  30.    * Änderungen:
  31.    *      07-Jul-93     Rolf Böhme        Erstellung
  32.    *
  33.    ***************************************************************************
  34.  */
  35.  
  36. #include "RSys.h"
  37. #include "protos.h"
  38.  
  39.  /*
  40.   * Standardtyp der Verschlüsselungart.
  41.   */
  42. static int type = CRY;
  43.  
  44.  /*
  45.   * Die Intuition-Objekte für den Aufbau des
  46.   * Crypt-Windows.
  47.   */
  48. static WINDOW *CryptWnd = NULL;
  49. static GADGET *CryptGList = NULL;
  50. static GADGET *CryptGadgets[8];
  51. static UWORD CryptLeft = 213;
  52. static UWORD CryptTop = 76;
  53. static UWORD CryptWidth = 278;
  54. static UWORD CryptHeight = 76;
  55. static UBYTE CryptWdt[100];    /*GMD */
  56.  
  57.  /*
  58.   * Diese Datei-lokale Struktur beinhaltet die Namen
  59.   * der Original- und der verschlüsselten Datei, sowie
  60.   * das Paßwort im Falle der Verschlüsselung mit dem
  61.   * "zellulären Automaten".
  62.   */
  63.  
  64. static RSYS_cryptdata cd =
  65.  
  66. {
  67.   "", "", "tiger"
  68. };
  69.  
  70. static UBYTE *TypeCYGad0Labels[] =
  71. {
  72.   (UBYTE *) "Crypt",
  73.   (UBYTE *) "ROT 13",
  74.   NULL};
  75.  
  76. static UWORD CryptGTypes[] =
  77. {
  78.   STRING_KIND,
  79.   STRING_KIND,
  80.   BUTTON_KIND,
  81.   BUTTON_KIND,
  82.   BUTTON_KIND,
  83.   BUTTON_KIND,
  84.   STRING_KIND,
  85.   CYCLE_KIND
  86. };
  87.  
  88. static NEWGADGET CryptNGad[] =
  89. {
  90.   66, 5, 132, 13, (UBYTE *) "Source", NULL, GD_SourceStrGad, PLACETEXT_LEFT, NULL, NULL,
  91.   66, 19, 132, 13, (UBYTE *) "Dest", NULL, GD_CryptStrGad, PLACETEXT_LEFT, NULL, NULL,
  92.   204, 5, 69, 13, (UBYTE *) "Select", NULL, GD_SelSourceGad, PLACETEXT_IN, NULL, NULL,
  93.   204, 19, 69, 13, (UBYTE *) "Select", NULL, GD_SelDestGad, PLACETEXT_IN, NULL, NULL,
  94.   98, 59, 81, 13, (UBYTE *) "Encrypt", NULL, GD_CryptGad, PLACETEXT_IN, NULL, NULL,
  95.   192, 59, 81, 13, (UBYTE *) "Decrypt", NULL, GD_DeccryptGad, PLACETEXT_IN, NULL, NULL,
  96.   66, 39, 207, 13, (UBYTE *) "Passwd", NULL, GD_PwdGad, PLACETEXT_LEFT, NULL, NULL,
  97.   4, 59, 81, 13, NULL, NULL, GD_TypeCYGad, 0, NULL, NULL
  98. };
  99.  
  100. static ULONG *CryptGTags[] =
  101. {
  102.   (ULONG *) (GTST_MaxChars), (ULONG *) MAXLINESIZE, (ULONG *) (TAG_DONE),
  103.   (ULONG *) (GTST_MaxChars), (ULONG *) MAXLINESIZE, (ULONG *) (TAG_DONE),
  104.   (ULONG *) (TAG_DONE),
  105.   (ULONG *) (TAG_DONE),
  106.   (ULONG *) (TAG_DONE),
  107.   (ULONG *) (TAG_DONE),
  108.   (ULONG *) (GTST_MaxChars), (ULONG *) 256, (ULONG *) (TAG_DONE),
  109.   (ULONG *) (GTCY_Labels), (ULONG *) & TypeCYGad0Labels[0], (ULONG *) (TAG_DONE)
  110. };
  111.  
  112.  /*
  113.   * Die Prozedur WindTitleInfo() läßt eine Nachricht in
  114.   * der Titelzeile des Crypt-Fensters erscheinen.
  115.   */
  116. static void
  117. WindTitleInfo (char *msg)
  118. {
  119.   SetWindowTitles (CryptWnd, (UBYTE *) (msg), (UBYTE *) (-1));
  120.   return;
  121. }
  122.  
  123.  /*
  124.   * OpenCryptWindow() öffnet ein Fenster mit allen Kontrollelementen
  125.   */
  126. int
  127. OpenCryptWindow (void)
  128. {
  129.   NEWGADGET ng;
  130.   GADGET *g;
  131.   UWORD lc, tc;
  132.   UWORD wleft = CryptLeft, wtop = CryptTop, ww, wh;
  133.   int gl[] =
  134.   {0, 1, 6};
  135.  
  136.   DPOS;
  137.  
  138.   AdjustWindowDimensions (Scr, CryptLeft, CryptTop, CryptWidth, CryptHeight,
  139.               &wleft, &wtop, &ww, &wh);
  140.  
  141.   if (!(g = CreateContext (&CryptGList)))
  142.     return 1L;
  143.  
  144.   for (lc = 0, tc = 0; lc < Crypt_CNT; lc++)
  145.     {
  146.  
  147.       CopyMem ((char *) &CryptNGad[lc], (char *) &ng,
  148.            (long) sizeof (NEWGADGET));
  149.  
  150.       ng.ng_VisualInfo = VisualInfo;
  151.       ng.ng_TextAttr = Font;
  152.       ng.ng_LeftEdge = OffX + ComputeX (ng.ng_LeftEdge);
  153.       ng.ng_TopEdge = OffY + ComputeY (ng.ng_TopEdge);
  154.       ng.ng_Width = ComputeX (ng.ng_Width);
  155.       ng.ng_Height = ComputeY (ng.ng_Height);
  156.  
  157.       CryptGadgets[lc] = g = CreateGadgetA ((ULONG) CryptGTypes[lc], g, &ng, (TAGITEM *) & CryptGTags[tc]);
  158.  
  159.       makelabelvisible (CryptGadgets[lc]);
  160.  
  161.       while (CryptGTags[tc])
  162.     tc += 2;
  163.       tc++;
  164.  
  165.       if (NOT g)
  166.     return 2L;
  167.     }
  168.  
  169.   strcpy (CryptWdt, get_vers (" - Crypting Files"));    /*GMD */
  170.  
  171.   if (!(CryptWnd = OpenWindowTags (NULL,
  172.                    WA_Left, wleft,
  173.                    WA_Top, wtop,
  174.                    WA_Width, ww,
  175.                    WA_Height, wh,
  176.                    WA_IDCMP, IDCMP_VANILLAKEY |
  177.                    STRINGIDCMP |
  178.                    BUTTONIDCMP |
  179.                    IDCMP_CLOSEWINDOW |
  180.                    IDCMP_REFRESHWINDOW,
  181.                    WA_Flags, WFLG_DRAGBAR |
  182.                    WFLG_DEPTHGADGET |
  183.                    WFLG_CLOSEGADGET |
  184.                    WFLG_SMART_REFRESH |
  185.                    WFLG_ACTIVATE |
  186.                    WFLG_RMBTRAP,
  187.                    WA_Title, CryptWdt,
  188.                    WA_PubScreenFallBack, TRUE,
  189.                    WA_PubScreen, Scr,
  190.                    TAG_DONE)))
  191.     return 4L;
  192.  
  193.   RefreshRastPort (CryptWnd, CryptGadgets, gl, 3, FALSE, CryptGList);
  194.  
  195.   return NULL;
  196. }
  197.  
  198.  /*
  199.   * refreshstrgad() erneuert den Inhalt eines Stringgadgets
  200.   */
  201. static void
  202. refreshstrgad (GADGET * gad, char *str)
  203. {
  204.   GT_SetGadgetAttrs (gad, CryptWnd, NULL, GTST_String, (UBYTE *) str, TAG_DONE);
  205.  
  206.   return;
  207. }
  208.  
  209.  /*
  210.   * Die nächsten Kommentare sind dem Programm-Quelltext von TERM entnommen.
  211.   * Olsen, danke für die Comments :-)
  212.   */
  213.  
  214.  /*
  215.   * The cell ring and the ring index pointers.
  216.   */
  217.  
  218. static UBYTE Cell[2][CELL_WIDTH + 2], From, To;
  219.  
  220.  /*
  221.   *  Automaton():
  222.   *
  223.   *     A cellular automaton working on a ring of celles, producing
  224.   *     random data in each single cell .
  225.   */
  226.  
  227. static UBYTE
  228. Automaton (void)
  229. {
  230.   WORD i;
  231.  
  232.   /*
  233.    * Operate on the cell ring...
  234.    */
  235.  
  236.   for (i = 1; i <= CELL_WIDTH; i++)
  237.     Cell[To][i] = Cell[From][i - 1] ^ (Cell[From][i] | Cell[From][i + 1]);
  238.  
  239.   /*
  240.    * Operate on first and last element.
  241.    */
  242.  
  243.   Cell[To][0] = Cell[From][CELL_WIDTH + 1] ^ (Cell[From][0] | Cell[From][1]);
  244.   Cell[To][CELL_WIDTH + 1] = Cell[From][CELL_WIDTH] ^ (Cell[From][CELL_WIDTH + 1] | Cell[From][0]);
  245.  
  246.   /*
  247.    * Swap cell rings.
  248.    */
  249.   To = From;
  250.   From ^= 1;
  251.  
  252.   /*
  253.    * Return contents of first cell.
  254.    */
  255.   return (Cell[From][0]);
  256. }
  257.  
  258.  /*
  259.   * Encrypt(UBYTE *Source,UBYTE *Destination,UBYTE *Key):
  260.   * Encrypt data using cellular automaton as a random number generator.
  261.   */
  262.  
  263. static UBYTE *
  264. Encrypt (UBYTE * Source, long SourceLen, UBYTE * Destination, UBYTE * Key, WORD KeyLen)
  265. {
  266.   long i, j;
  267.  
  268.   /*
  269.    * Set up cell ring index pointers.
  270.    */
  271.   From = 0;
  272.   To = 1;
  273.  
  274.   /*
  275.    * Initialize the cell ring with the key contents.
  276.    */
  277.   for (i = 0, j = KeyLen - 1; i < CELL_WIDTH + 2; i++)
  278.     {
  279.       Cell[0][i] = Key[j];
  280.  
  281.       if (j)
  282.     j--;
  283.       else
  284.     j = KeyLen - 1;
  285.     }
  286.  
  287.   /*
  288.    * Encrypt the source data.
  289.    */
  290.   for (i = 0; i < SourceLen; i++)
  291.     Destination[i] = (UBYTE) (((WORD) Source[i] + Automaton ()) % 256);
  292.  
  293.   /*
  294.    * Return result.
  295.    */
  296.   return Destination;
  297. }
  298.  
  299.  /*
  300.   * Decrypt(UBYTE *Source,UBYTE *Destination,UBYTE *Key):
  301.   *
  302.   *     Decrypt data using cellular automaton as a random number generator.
  303.   */
  304.  
  305. static UBYTE *
  306. Decrypt (UBYTE * Source, long SourceLen, UBYTE * Destination, UBYTE * Key, WORD KeyLen)
  307. {
  308.   long i, j, Code;
  309.  
  310.   /*
  311.    * Set up cell ring index pointers.
  312.    */
  313.   From = 0;
  314.   To = 1;
  315.  
  316.   /*
  317.    * Initialize the cell ring with the key contents.
  318.    */
  319.   for (i = 0, j = KeyLen - 1; i < CELL_WIDTH + 2; i++)
  320.     {
  321.       Cell[0][i] = Key[j];
  322.  
  323.       if (j)
  324.     j--;
  325.       else
  326.     j = KeyLen - 1;
  327.     }
  328.  
  329.   /*
  330.    * Decrypt the source data.
  331.    */
  332.   for (i = 0; i < SourceLen; i++)
  333.     {
  334.       if ((Code = Source[i] - Automaton ()) < 0)
  335.     Code = 256 + Code;
  336.  
  337.       Destination[i] = (UBYTE) Code;
  338.     }
  339.  
  340.   return Destination;
  341. }
  342.  
  343.  /*
  344.   * Die Prozedur MakeROT13() erzeugt aus einem
  345.   * Eingabestring buff eine Ausgabestring dest
  346.   * dergestalt, daß jeder Buchstabe um 13 Zeichen nach
  347.   * vorne oder hinten verschoben wird. Hier die
  348.   * Translationsliste:
  349.   *
  350.   * Input:              abcdefghijklmnopqrstuvwxyz
  351.   * Output:             nopqrstuvwxyzabcdefghijklm
  352.   *
  353.   * Input:              ABCDEFGHIJKLMNOPQRSTUVWXYZ
  354.   * Output:             NOPQRSTUVWXYZABCDEFGHIJKLM
  355.   */
  356. static void
  357. MakeROT13 (UBYTE * buff, UBYTE * dest)
  358. {
  359.   UBYTE *destptr = &dest[0];
  360.   char ch;
  361.  
  362.   strcpy ((char *) dest, (char *) buff);
  363.  
  364.   while (*destptr)
  365.     {
  366.       ch = (char) (*destptr);
  367.  
  368.       if (isalpha ((int) ch))
  369.     {
  370.       if (((ch >= 'A') && (ch < 'N')) || ((ch >= 'a') && (ch < 'n')))
  371.         *destptr = (UBYTE) (ch + 13);
  372.  
  373.       if (((ch >= 'N') && (ch <= 'Z')) || ((ch >= 'n') && (ch <= 'z')))
  374.         *destptr = (UBYTE) (ch - 13);
  375.     }
  376.  
  377.       destptr++;
  378.     }
  379.  
  380.   return;
  381. }
  382.  
  383.  /*
  384.   * Crypt() ver- oder entschlüsselt eine Datei
  385.   */
  386. static void
  387. Crypt (int encrypt)
  388. {
  389.   long fsize;
  390.   char pwd[PWDLEN + 1], cpwd[PWDLEN + 1];
  391.   BPTR Dfile, Cfile;
  392.   UBYTE *Dbuffer, *Cbuffer;
  393.   int pwdlen;
  394.  
  395.   if (strlen (cd.cr_pwd) == 0)
  396.     strcpy (pwd, "tiger");
  397.   else
  398.     strncpy (pwd, cd.cr_pwd, PWDLEN);
  399.  
  400.   pwdlen = strlen (pwd);
  401.  
  402.   if (encrypt)
  403.     {
  404.       if (NOT (exist (cd.cr_datafile)))
  405.     {
  406.       ErrorHandle (cd.cr_datafile, FILE_ERR, EXIST_FAIL, NO_KILL);
  407.       return;
  408.     }
  409.  
  410.       if (type == R13)
  411.     {
  412.  
  413.       filetype (cd.cr_datafile);
  414.       if (global_type != TYPE_TEXT)
  415.         {
  416.           ErrorHandle (cd.cr_datafile, FILE_ERR, TYPE_FAIL, NO_KILL);
  417.           return;
  418.         }
  419.     }
  420.  
  421.       fsize = SizeOfFile (cd.cr_datafile);
  422.       if (fsize == 0L)
  423.     {
  424.       ErrorHandle (cd.cr_datafile, FILE_ERR, SIZE_FAIL, NO_KILL);
  425.       return;
  426.     }
  427.  
  428.       if (exist (cd.cr_cryptfile) && NOT (Question (CryptWnd, "Crypt file exist!\n"
  429.                     "Do you want to overwrite them?", YES)))
  430.     return;
  431.  
  432.       if (Dfile = Open ((UBYTE *) cd.cr_datafile, MODE_OLDFILE))
  433.     {
  434.       if (Cfile = Open ((UBYTE *) cd.cr_cryptfile, MODE_NEWFILE))
  435.         {
  436.           if ((Dbuffer = MyAllocVec ((fsize + 1) * sizeof (UBYTE), MEMF_CLEAR, NO_KILL)) &&
  437.           (Cbuffer = MyAllocVec ((fsize + 1) * sizeof (UBYTE), MEMF_CLEAR, NO_KILL)))
  438.         {
  439.           WindTitleInfo ("Reading datafile...");
  440.           if (fsize == Read (Dfile, Dbuffer, fsize))
  441.             {
  442.               if (NOT (type))
  443.             {
  444.               WindTitleInfo ("Encrypt password...");
  445.               Encrypt ((UBYTE *) pwd, (long) pwdlen, (UBYTE *) cpwd,
  446.                    (UBYTE *) pwd, (WORD) pwdlen);
  447.  
  448.               if (pwdlen != Write (Cfile, cpwd, pwdlen))
  449.                 ErrorHandle (cd.cr_cryptfile, FILE_ERR, WRITE_FAIL, NO_KILL);
  450.               else
  451.                 {
  452.                   WindTitleInfo ("Encrypt data file...");
  453.                   Cbuffer = Encrypt (Dbuffer, (long) fsize,
  454.                      Cbuffer, (UBYTE *) pwd, (WORD) pwdlen);
  455.                 }
  456.             }
  457.               else
  458.             {
  459.               WindTitleInfo ("Rotate data file...");
  460.               MakeROT13 (Dbuffer, Cbuffer);
  461.             }
  462.  
  463.               WindTitleInfo (type ? "Writing ROT13 file..." : "Writing crypt file...");
  464.               if (fsize != Write (Cfile, Cbuffer, fsize))
  465.             ErrorHandle (cd.cr_cryptfile, FILE_ERR, WRITE_FAIL, NO_KILL);
  466.             }
  467.           else
  468.             ErrorHandle (cd.cr_datafile, FILE_ERR, READ_FAIL, NO_KILL);
  469.  
  470.           MyFreeVec (Cbuffer);
  471.           MyFreeVec (Dbuffer);
  472.         }
  473.  
  474.           Close (Cfile);
  475.         }
  476.       else
  477.         ErrorHandle (cd.cr_cryptfile, FILE_ERR, OPEN_FAIL, NO_KILL);
  478.  
  479.       Close (Dfile);
  480.     }
  481.       else
  482.     ErrorHandle (cd.cr_datafile, FILE_ERR, OPEN_FAIL, NO_KILL);
  483.     }
  484.   else
  485.     {
  486.       if (NOT (exist (cd.cr_cryptfile)))
  487.     {
  488.       ErrorHandle (cd.cr_cryptfile, FILE_ERR, EXIST_FAIL, NO_KILL);
  489.       return;
  490.     }
  491.  
  492.       fsize = SizeOfFile (cd.cr_cryptfile);
  493.       if (fsize == 0L)
  494.     {
  495.       ErrorHandle (cd.cr_cryptfile, FILE_ERR, SIZE_FAIL, NO_KILL);
  496.       return;
  497.     }
  498.  
  499.       if (exist (cd.cr_datafile) &&
  500.       NOT (Question (CryptWnd, "Data file exist!\n" "Do you want to overwrite them?", YES)))
  501.     return;
  502.  
  503.       if (Dfile = Open ((UBYTE *) cd.cr_datafile, MODE_NEWFILE))
  504.     {
  505.       if (Cfile = Open ((UBYTE *) cd.cr_cryptfile, MODE_OLDFILE))
  506.         {
  507.           if ((Dbuffer = MyAllocVec ((fsize + 1) * sizeof (UBYTE), MEMF_CLEAR, NO_KILL)) &&
  508.           (Cbuffer = MyAllocVec ((fsize + 1) * sizeof (UBYTE), MEMF_CLEAR, NO_KILL)))
  509.         {
  510.           WindTitleInfo (type ? "Reading ROT13 file..." : "Reading crypt file...");
  511.           if (fsize == Read (Cfile, Cbuffer, fsize))
  512.             {
  513.               if (NOT (type))
  514.             {
  515.               WindTitleInfo ("Decrypt password...");
  516.  
  517.               strncpy (cpwd, (char *) Cbuffer, pwdlen);
  518.               Decrypt ((UBYTE *) cpwd, (long) pwdlen,
  519.                    (UBYTE *) pwd, (UBYTE *) pwd, (WORD) pwdlen);
  520.  
  521.               if (strcmp (cd.cr_pwd, pwd))
  522.                 ErrorHandle ("Password", MISC_ERR, WRONG_FAIL, NO_KILL);
  523.               else
  524.                 {
  525.                   WindTitleInfo ("Decrypt crypt file...");
  526.                   Dbuffer = Decrypt (&Cbuffer[pwdlen], (long) (fsize - pwdlen),
  527.                      Dbuffer, (UBYTE *) pwd, (WORD) pwdlen);
  528.                 }
  529.             }
  530.               else
  531.             {
  532.               WindTitleInfo ("Derotate ROT13-File...");
  533.               MakeROT13 (Cbuffer, Dbuffer);
  534.             }
  535.  
  536.               WindTitleInfo ("Writing data file...");
  537.  
  538.               fsize -= (type ? 0 : pwdlen);
  539.               if (fsize != Write (Dfile, Dbuffer, fsize))
  540.             ErrorHandle (cd.cr_datafile, FILE_ERR, WRITE_FAIL, NO_KILL);
  541.             }
  542.           else
  543.             ErrorHandle (cd.cr_cryptfile, FILE_ERR, READ_FAIL, NO_KILL);
  544.  
  545.           MyFreeVec (Cbuffer);
  546.           MyFreeVec (Dbuffer);
  547.         }
  548.  
  549.           Close (Cfile);
  550.         }
  551.       else
  552.         ErrorHandle (cd.cr_cryptfile, FILE_ERR, OPEN_FAIL, NO_KILL);
  553.  
  554.       Close (Dfile);
  555.     }
  556.       else
  557.     ErrorHandle (cd.cr_datafile, FILE_ERR, OPEN_FAIL, NO_KILL);
  558.     }
  559.  
  560.   strcpy (CryptWdt, get_vers (" - Crypting Files"));    /*GMD */
  561.  
  562.   WindTitleInfo ((char *) CryptWdt);
  563.  
  564.   return;
  565. }
  566.  
  567.  /*
  568.   * CryptFile() bietet eine kleine Benutzeroberfläche an und
  569.   * kontrolliert die Ein- und Ausgabedateien sowie das Paßwort
  570.   */
  571. void
  572. CryptFile (void)
  573. {
  574.   INTUIMESSAGE *message;
  575.   ULONG class, code;
  576.   APTR object;
  577.   APTR reqcrypt = NULL;
  578.   char *gadbuff;
  579.   int GID;
  580.  
  581.   DPOS;
  582.  
  583.   HandleHelp (MN_CryptFile);
  584.  
  585.   Flags.quit_cr = 0;
  586.  
  587.   cd.cr_datafile[0] = STRINGEND;
  588.   cd.cr_cryptfile[0] = STRINGEND;
  589.   strcpy (cd.cr_pwd, "tiger");
  590.  
  591.   if (OpenASysWindow (OpenCryptWindow, NO_KILL))
  592.     {
  593.       LockMainWindow (WIN_LOCK);
  594.  
  595.       refreshstrgad (CryptGadgets[GD_SourceStrGad - GD_SourceStrGad], cd.cr_datafile);
  596.       refreshstrgad (CryptGadgets[GD_CryptStrGad - GD_SourceStrGad], cd.cr_cryptfile);
  597.       refreshstrgad (CryptGadgets[GD_PwdGad - GD_SourceStrGad], cd.cr_pwd);
  598.  
  599.       do
  600.     {
  601.       Wait (1L << CryptWnd->UserPort->mp_SigBit);
  602.  
  603.       while ((message = (INTUIMESSAGE *)
  604.           GT_GetIMsg (CryptWnd->UserPort)) != NULL)
  605.         {
  606.           object = message->IAddress;
  607.           class = message->Class;
  608.           code = message->Code;
  609.  
  610.           GT_ReplyIMsg (message);
  611.  
  612.           switch (class)
  613.         {
  614.         case IDCMP_GADGETUP:
  615.           GID = ((GADGET *) object)->GadgetID;
  616.  
  617.           HandleHelp ((enum RSysNumbers) GID);
  618.  
  619.           switch (GID)
  620.             {
  621.             case GD_SourceStrGad:
  622.               gadbuff = gadgetbuff (CryptGadgets[GD_SourceStrGad - GD_SourceStrGad]);
  623.  
  624.               strncpy (cd.cr_datafile, gadbuff, MAXFULLNAME);
  625.               strncpy (cd.cr_cryptfile, gadbuff, MAXFULLNAME);
  626.               strcat (cd.cr_cryptfile, (type ? ".ROT" : ".CPT"));
  627.  
  628.               refreshstrgad (CryptGadgets[GD_CryptStrGad - GD_SourceStrGad],
  629.                      cd.cr_cryptfile);
  630.               break;
  631.  
  632.             case GD_CryptStrGad:
  633.               gadbuff = gadgetbuff (CryptGadgets[GD_CryptStrGad - GD_SourceStrGad]);
  634.               strncpy (cd.cr_cryptfile, gadbuff, MAXFULLNAME);
  635.               break;
  636.  
  637.             case GD_SelSourceGad:
  638.               if (GetFile (CryptWnd, NULL, NULL, NULL,
  639.                    "Select File to crypt", "Select"))
  640.             {
  641.               strncpy (cd.cr_datafile, (char *) _fullpath,
  642.                    MAXFULLNAME);
  643.  
  644.               strncpy (cd.cr_cryptfile, (char *) _fullpath,
  645.                    MAXFULLNAME - 4);
  646.               strcat (cd.cr_cryptfile, (type ? ".ROT" : ".CPT"));
  647.  
  648.               refreshstrgad (CryptGadgets[GD_SourceStrGad - GD_SourceStrGad],
  649.                      cd.cr_datafile);
  650.               refreshstrgad (CryptGadgets[GD_CryptStrGad - GD_SourceStrGad],
  651.                      cd.cr_cryptfile);
  652.             }
  653.  
  654.               break;
  655.  
  656.             case GD_SelDestGad:
  657.               if (GetFile (CryptWnd, NULL, NULL,
  658.                    (type ? "#?.ROT" : "#?.CPT"),
  659.              (type ? "Select ROT13 file" : "Select Crypt file"),
  660.                    "Select"))
  661.             {
  662.               strncpy (cd.cr_cryptfile, (char *) _fullpath, MAXFULLNAME);
  663.               refreshstrgad (CryptGadgets[GD_CryptStrGad - GD_SourceStrGad],
  664.                      cd.cr_cryptfile);
  665.             }
  666.               break;
  667.  
  668.             case GD_CryptGad:
  669.               reqcrypt = LockWindow (CryptWnd);
  670.  
  671.               Crypt (TRUE);
  672.  
  673.               UnlockWindow (reqcrypt);
  674.               break;
  675.  
  676.             case GD_DeccryptGad:
  677.               reqcrypt = LockWindow (CryptWnd);
  678.  
  679.               Crypt (FALSE);
  680.  
  681.               UnlockWindow (reqcrypt);
  682.               break;
  683.  
  684.             case GD_PwdGad:
  685.               strncpy (cd.cr_pwd, gadgetbuff (CryptGadgets[GD_PwdGad - GD_SourceStrGad]), 20);
  686.               break;
  687.  
  688.             case GD_TypeCYGad:
  689.               type = (int) code;
  690.               EnableGadget (CryptWnd, CryptGadgets[GD_PwdGad - GD_SourceStrGad],
  691.                     NOT (type));
  692.  
  693.               if (cd.cr_datafile[0])
  694.             {
  695.               strncpy (cd.cr_cryptfile, cd.cr_datafile, MAXFULLNAME - 4);
  696.               strcat (cd.cr_cryptfile, (type ? ".ROT" : ".CPT"));
  697.  
  698.               refreshstrgad (CryptGadgets[GD_CryptStrGad - GD_SourceStrGad],
  699.                      cd.cr_cryptfile);
  700.             }
  701.               break;
  702.             }
  703.  
  704.           break;
  705.  
  706.         case IDCMP_VANILLAKEY:
  707.           if (code == ESC)
  708.             Flags.quit_cr = 1;
  709.           break;
  710.  
  711.         case IDCMP_CLOSEWINDOW:
  712.           Flags.quit_cr = 1;
  713.           break;
  714.         }
  715.         }
  716.     }
  717.       while (NOT (Flags.quit_cr));
  718.  
  719.       CloseASysWindow (&CryptWnd, &CryptGList, NULL);
  720.  
  721.       LockMainWindow (WIN_UNLOCK);
  722.     }
  723.  
  724.   return;
  725. }
  726.